import util from "/common/js/util.js";

// components/zero-audio/index.js
var audioManager = dd.getBackgroundAudioManager()
// audioManager.onEnded(()=>{
//   this.debug('音频结束播放')
//     this.setData({
//       isPaused: true
//     })
// })
var app = getApp();



Component({
  /**
   * 组件的属性列表
   */
  props: {
    /**
     * 音频地址
     */
    title: '音乐播放',
    min: 0,
    max: 100,
    duration: 0, //微秒
    step: 0.1,
    /**
     * 滚动条当前值
     */
    value: 0,
    /**
     * 是否禁用滚动条
     */
    disabled: true,
    /**
     * 背景条的颜色，滚动条默认背景颜色
     * #ddd  #ecf9ff
     */
    backgroundColor: '#888',
    /**
     * 已选择的颜色，滚动条激活背景颜色
     */
    activeColor: '#26a9e1',
    /**
     * 滑块的大小
     */
    blockSize: 18,
    /**
     * 滑块的颜色
     */
    blockColor: '#ffffff',
    /**
     * 是否显示当前 value
     */
    showValue: false,

    title:"",index:-1,
    dataList:[],
    view:true,//查看模式
    noPage:false,//去除页码和标题
    onDeleteFn: function onDeleteFn(e){},
    onErrorFn: function onErrorFn(e){},
  },

  /**
   * 组件的初始数据
   */
  data: {
    // 处理音频的interval对象
    _audioInterval: null,

    // 用户是否正在拖动slider
    _isUserSliding: false,

    // 判断是否seek结束，用来保证界面slider的稳定
    _isSeeking: false,

    // 用来处理showLoading与hideLoading不一致的问题
    _showLoading: false,

    // 是否需要加载播放，也就是说，新进来或是不同音频，点击播放需要调用loading
    _needPlayLoading: true,

    //是否暂停了，默认就是暂停
    isPaused: true,

    playbackRateArray: [0.5, 1, 1.25, 1.5, 2.0],
    currentPlaybackRate: 1,

    // 总时长显示
    durationText: '00:00',
    //当前进长显示
    currentTimeText: '00:00',

    title:"",
    view:false,//查看模式
    noPage:false,//去除页码和标题
    dataList:[],
    enableNative:false
  },
  options: {
    // 指定所有 _ 开头的数据字段为纯数据字段
    pureDataPattern: /^_/
  },

  /**
   * 2.2.3
   */
  pageLifetimes: {
    show: function () {
      // 页面被展示
    },
    hide: function () {
      // 页面被隐藏
    },
    resize: function (size) {
      // 页面尺寸变化
    }
  },
  /**
   * 2.2.3
   */
  lifetimes: {
    attached: function () {
      // this.debug('组件装配成功')
      // console.debug(typeof this.data.audioInfo)
      // // 在组件实例进入页面节点树时执行
      // 不在timeupdate中处理slider的滚动

    },
    detached: function () {
      // 在组件实例被从页面节点树移除时执行
      this.debug('组件移除')
      if (this.data._audioInterval) {
        clearInterval(this.data._audioInterval)
      }
    },
  },
  

  didMount(e) {
      this.initF();
    //  this.initAudio();
  },
  didUpdate(prevProps, prevData) {


  },
  didUnmount(){
    audioManager.stop();
  },
  /**
   * 组件的方法列表
   */
  methods: {
    initF(){
      let dataList=this.props.dataList;
      
      for(let a=0;a<dataList.length;a++){
        let item=dataList[a];
        item.value=0;
        item.currentTimeText="00:00";
        item.remoteUrl=this.getUrl(item);
        let duration = this.getDuration(item);
        
        item.durationText= this.format(duration);
        item.isPaused =true;
      }
      this.setData({
        dataList,
        view:this.props.view,
        noPage: this.props.noPage
      })

      dd.getSystemInfo({
        success: (res) => {
          // res.platform;
       //   console.log("--res.platform", res.platform);
          if (res.platform == "iOS") {
            this.setData({
              enableNative: true
            })
          }
        }
      })
  
      if (app.prototype.$userName == "刘庆峰") {
        this.setData({
          enableNative:true
        })
      }

    },
    format(seconds) { //秒转化为分钟格式
      let s = Math.trunc(seconds);
      let minInt = Math.floor(s / 60);
      let min = minInt >= 10 ? minInt : '0' + minInt;
      s -= 60 * min;
      let sec = s >= 10 ? s : '0' + s;
      return min + ':' + sec;
    },
    showLoading(options) {
      this.setData({
        _showLoading: true
      })
      dd.showLoading(options)
    },
    hideLoading() {
      // 如果显示了加载动画，才进行隐藏
      if (this.data._showLoading) {
        this.setData({
          _showLoading: false
        })
        dd.hideLoading()
      }
    },
    /**
     * 输出调试信息
     * @param msg 信息
     */
    debug(...msg) {
      return;
      msg[0] = '%c[' + msg[0] + ']'
      msg.splice(1, 0, 'color:#1AAD19')
      console.debug(...msg)
    },
    /**
     * 将时间秒转换成00:00的格式
     * @param totalSecond 秒数
     */
    time2Text(totalSecond) {
      let second = Math.ceil(totalSecond % 60)
      let minute = Math.floor(totalSecond / 60)
      second = second < 10 ? '0' + second : second
      minute = minute < 10 ? '0' + minute : minute
      return `${minute}:${second}`
    },
    /**
     * 设置音频参数，当src变化时，必须调用设置音频配置信息
     * @param e
     */
    setAudioOption(e) {
      audioManager.title = this.data.title
      audioManager.epname = this.data.title
      audioManager.singer = this.data.title
      audioManager.coverImgUrl = ''
    },

    getDuration(item) {
      
      let duration = parseInt(item.duration);
      if (item.remoteUrl.indexOf(".audio")!=-1) {
        duration = duration / 1000;
      }
      return duration;
    },
    getUrl(item){
      let url=util.isNotEmpty(item.mp3Url)?item.mp3Url:item.remoteUrl;
      return url;
    },
    /**
     * 初始化音频信息
     */
    initAudio(index) {
      // this.debug('初始化背景音频播放器', audioManager, audioManager.paused, )


      // let audioManager = dd.getBackgroundAudioManager()
    

      if (typeof audioManager.paused === 'undefined') {
        console.log("背景音频没有任何播放的内容");

      } else if (!audioManager.paused) {
        // this.setData({
        //   disabled: false,
        //   isPaused: false,
        // })
      }
      // let duration = this.getDuration();
      // let durationText = this.format(duration);

      // this.setData({
      //   durationText
      // })
      // console.log("---audioManager:",audioManager);
    //  this.debug(audioManager.src, this.props.src)

      // 如果正在播放的音频与当前将要播放的音频不一致，则停止播放
      // if (audioManager.src != this.props.src) {
      //   this.setData({
      //     _needPlayLoading: true
      //   })
      //   audioManager.stop();
      // }

      // audioManager.onCanplay(() => {
      //     this.hideLoading()
      //     this.debug('音频可以播放了')
      // })
      // audioManager.onWaiting(() => {
      //     this.debug('音频正在加载')
      // })
      // audioManager.onError(() => {
      //     this.debug('音频异常')
      // })
      // console.log(audioManager);
      // debugger
      // audioManager.onPlay({
      //   success: () => {
      //     this.hideLoading()
      //     this.debug('音频正在播放')
      //     this.setData({
      //       isPaused: false
      //     })
      //   },
      //   fail: () => {},
      //   complete: () => {},
      // })

      let events = ["onPlay", "onPause", "onStop", "onEnded", "onTimeUpdate", "onError", "onWaiting"];
      // events.forEach(item => {

      // })

      let that = this;
      audioManager.onEnded = function (event) {
       that.stopThread()
      };
      audioManager.onStop = function (event) {
        that.stopThread()
      };
      
      audioManager.onError = function (error) {
        console.log(error);
        util.message("抱歉该音频文件暂时无法进行播放,请稍后重试！");
        this.props.onErrorFn(error);
      };
      audioManager.onPlay = function (event) {
        
        let dataList = that.data.dataList;
        let item= dataList[index];
        item.isPaused=false
        that.setData({
          [`dataList[${index}]`]:item
        })
      };

      audioManager.onPause = function (event) {
       // console.log("--音频暂停");
        
        let dataList = that.data.dataList;
        let item= dataList[index];
        item.isPaused=true
        that.setData({
          [`dataList[${index}]`]:item
        })
      };

      audioManager.onSeeking = function (e) {
       // console.log("--音频正在seeking");
       // that.stopThread();
      }


      audioManager.onSeeked = function (e) {
        // console.log("--音频seek结束");
        that.setData({
          _isSeeking: false,
          isPaused:false
        })
      //  console.log("--调至指定位置:",that.data.value);

      // that.runThread();
      }

      /**
       * 监听背景音频播放进度更新事件，只有小程序在前台时会回调。
       */
      audioManager.onTimeUpdate= function (e){
       // console.log("--播放进度更新",e.currentTime);
        let currentTime=e.currentTime;
        let duration = audioManager.duration;
          let durationText="00:00";
        let currentValue = currentTime / duration * 100
        if (currentValue > 100) {
          currentValue = 100
        }
        
        durationText= that.format(duration);

        //time2Text
        let currentTimeText = that.format(currentTime);
        let dataList=that.data.dataList;
        for(let a=0;a<dataList.length;a++){
           let item= dataList[a];
           if(!item.isPaused){
            item.value=currentValue;
            item.currentTimeText=currentTimeText;
            item.durationText=durationText;
            that.setData({
              [`dataList[${a}]`]:item
            })
            // console.log(that.data[`dataList[${a}]`]);
           }
        };
      }
    
    },
    /**
     * 完成一次拖动后触发的事件，event.detail = {value}
     */
    changeCallback(e) {
      //console.log('[完成一次拖动]', e)
      let sliderValue = e.detail.value // 滚动条滚动后的值
      this.halfStopThread();

      let dataList=this.data.dataList;
        for(let a=0;a<dataList.length;a++){
           let item= dataList[a];
           if(!item.isPaused){
            item.value=sliderValue;
           
            this.setData({
              [`dataList[${a}]`]:item
            })
           }
        }
    //  console.log("--跳：",this.data.value);
      this.gotoPosition(sliderValue)
    },

    deleteFn(e){
      let index = e.currentTarget.dataset.index;
      this.props.onDeleteFn(index);
    },
    gotoPosition(sliderValue) {
      let duration = audioManager.duration;
      let seek=sliderValue / 100 * duration
      // console.log("--跳：",seek);
      // audioManager.play();
      audioManager.seek(seek);
    //  console.log("--调整至指定位置:",sliderValue);
    },
    /**
     * 拖动过程中触发的事件，event.detail = {value}
     */
    changingCallback(e) {
      //  console.log('[拖动过程中]', e)
      this.setData({
        _isUserSliding: true
      })
    },

    /**
     * 暂停
     */
    pauseAudio() {
      audioManager.pause();
      // audioManager.stop();
      
      let dataList = this.data.dataList;

      for(let a=0;a<dataList.length;a++){
        let item= dataList[a];
        if(!item.isPaused){
          item.isPaused=true;
         this.setData({
          [`dataList[${a}]`]:item
         })
        }
      }
    },
    /**
     * 播放
     */
    playAudio(e) {
      let index = e.currentTarget.dataset.index;
      let item =this.data.dataList[index];
      // console.log(item);

      // return false;
      // 如果需要加载播放，则进行第一次播放
      this.initAudio(index);
     
      // 如果正在播放的音频与当前将要播放的音频不一致，则停止播放
      if (audioManager.src != item.remoteUrl) {
        this.setData({
          _needPlayLoading: true
        })
        audioManager.stop();
        this.stopThread();
        
      }

    //  console.log(audioManager.title);


      if (this.data._needPlayLoading) {
        // this.showLoading({
        //   title: '准备播放',
        //   mask: true
        // })
        this.setData({
          _needPlayLoading: false
        })

        this.setAudioOption();
        // console.log(this.props.src);
        // let duration = this.props.duration / 1000;
        // audioManager.duration=duration;
        audioManager.src = item.remoteUrl;
        audioManager.title=index;
         audioManager.play()
      } else {
        // 音频正常点击播放
        // if (this.data.value > 0) {
        //   // this.gotoPosition(this.data.value);
          
        // } else {
        //   audioManager.play()
        // }
        audioManager.play()
      }
      
    },
    runThread() {
      let audioInterval = setInterval(() => {
        // 如果用户正在拖动，就先不改变界面的值
        if (this.data._isUserSliding) {
          return
        }
        if (this.data.isPaused) {
          return
        }
        // 如果正在seek，则先不进行渲染
        // if (this.data._isSeeking) {
        //     return;
        // }
        let currentTime = audioManager.currentTime,
          duration = audioManager.duration;
          let durationText="00:00";
        let currentValue = currentTime / duration * 100
        if (currentValue > 100) {
          currentValue = 100
        }
        if(duration>0){
          durationText= this.time2Text(duration);
        }
        
        let currentTimeText = this.time2Text(currentTime);
        // console.log("---currentTimeText:",currentTimeText);
        this.setData({
          value: currentValue,
          currentTimeText,
          durationText,
        })
        // this.debug('正在渲染滚动条值')
      }, 500)
      this.setData({
        _audioInterval: audioInterval
      })
    },
    //完全停止线程
    stopThread() {
      // if (this.data._audioInterval) {
      //   clearInterval(this.data._audioInterval)
      // }
      // let duration = audioManager.duration
      // let duration = this.getDuration();
      // this.setData({
      //   value:0,
      //   isPaused:true,
      //   currentTimeText: "00:00",
      //   durationText: this.time2Text(duration)
      // })
      let dataList=this.data.dataList;
        for(let a=0;a<dataList.length;a++){
           let item= dataList[a];
           if(!item.isPaused){
            item.value=0;
            item.isPaused=true;
            item.currentTimeText="00:00";
            let durationText=this.getDuration(item);
            item.durationText=this.time2Text(durationText);
            this.setData({
              [`dataList[${a}]`]:item
            })
           }
        }
      // console.log("--isPaused",this.props.index,this.data.isPaused);
    },
   //半停状态 只停线程不重置其他参数
   halfStopThread(){
    if (this.data._audioInterval) {
      clearInterval(this.data._audioInterval)
    }
   }
  }
})